org.springframework.http.server.reactive

Class AbstractListenerWriteFlushProcessor<T>

java.lang.Object

org.springframework.http.server.reactive.AbstractListenerWriteFlushProcessor<T>

Direct Known Subclasses:

ServletServerHttpResponse.ResponseBodyFlushProcessor, UndertowServerHttpResponse.ResponseBodyFlushProcessor

public abstract class AbstractListenerWriteFlushProcessor<T>
extends java.lang.Object

An alternative to AbstractListenerWriteProcessor but instead writing a Publisher<Publisher<T>> with flush boundaries enforces after the completion of each nested Publisher.

Since:

5.0

Author:

Arjen Poutsma, Violeta Georgieva, Rossen Stoyanchev

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
private static class	AbstractListenerWriteFlushProcessor.State Represents a state for the Processor to be in.

Field Summary

Fields

Modifier and Type	Field and Description
protected Log	logger
private WriteResultPublisher	resultPublisher
private java.util.concurrent.atomic.AtomicReference<AbstractListenerWriteFlushProcessor.State>	state
private boolean	subscriberCompleted
private Subscription	subscription

Constructor Summary

Constructors

Constructor and Description
AbstractListenerWriteFlushProcessor()

Method Summary

Modifier and Type	Method and Description
protected void	cancel() Invoked during an error or completion callback from the underlying container to cancel the upstream subscription.
private boolean	changeState(AbstractListenerWriteFlushProcessor.State oldState, AbstractListenerWriteFlushProcessor.State newState)
protected abstract <any>	createWriteProcessor() Create a new processor for the current flush boundary.
protected abstract void	flush() Flush the output if ready, or otherwise isFlushPending() should return true after.
private void	flushIfPossible()
protected void	flushingFailed(java.lang.Throwable t) Invoked when an error happens while flushing.
protected abstract boolean	isFlushPending() Whether flushing is pending.
protected abstract boolean	isWritePossible() Whether writing/flushing is possible.
void	onComplete() Completion signal from the upstream, write Publisher.
void	onError(java.lang.Throwable ex) Error signal from the upstream, write Publisher.
protected void	onFlushPossible() Invoked when flusing is possible, either in the same thread after a check via isWritePossible(), or as a callback from the underlying container.
void	onNext(<any> publisher)
void	onSubscribe(Subscription subscription)
void	subscribe(<any> subscriber)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

logger

protected final Log logger

state

private final java.util.concurrent.atomic.AtomicReference<AbstractListenerWriteFlushProcessor.State> state

subscription

@Nullable
private Subscription subscription

subscriberCompleted

private volatile boolean subscriberCompleted

resultPublisher

private final WriteResultPublisher resultPublisher

Constructor Detail

AbstractListenerWriteFlushProcessor

public AbstractListenerWriteFlushProcessor()

Method Detail

onSubscribe

public final void onSubscribe(Subscription subscription)

onNext

public final void onNext(<any> publisher)

onError

public final void onError(java.lang.Throwable ex)

Error signal from the upstream, write Publisher. This is also used by sub-classes to delegate error notifications from the container.

onComplete

public final void onComplete()

Completion signal from the upstream, write Publisher. This is also used by sub-classes to delegate completion notifications from the container.

onFlushPossible

protected final void onFlushPossible()

Invoked when flusing is possible, either in the same thread after a check via isWritePossible(), or as a callback from the underlying container.

cancel

protected void cancel()

Invoked during an error or completion callback from the underlying container to cancel the upstream subscription.

subscribe

public final void subscribe(<any> subscriber)

createWriteProcessor

protected abstract <any> createWriteProcessor()

Create a new processor for the current flush boundary.

isWritePossible

protected abstract boolean isWritePossible()

Whether writing/flushing is possible.

flush

protected abstract void flush()
                       throws java.io.IOException

Flush the output if ready, or otherwise isFlushPending() should return true after.

This is primarily for the Servlet non-blocking I/O API where flush cannot be called without a readyToWrite check.

Throws:

java.io.IOException

isFlushPending

protected abstract boolean isFlushPending()

Whether flushing is pending.

This is primarily for the Servlet non-blocking I/O API where flush cannot be called without a readyToWrite check.

flushingFailed

protected void flushingFailed(java.lang.Throwable t)

Invoked when an error happens while flushing. Sub-classes may choose to ignore this if they know the underlying API will provide an error notification in a container thread.

Defaults to no-op.

changeState

private boolean changeState(AbstractListenerWriteFlushProcessor.State oldState,
                            AbstractListenerWriteFlushProcessor.State newState)

flushIfPossible

private void flushIfPossible()